/*
 *  Driver for Freescale's 3-Axis Accelerometer MMA8450
 *
 *  Copyright (C) 2011-2014 Freescale Semiconductor, Inc. All Rights Reserved.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/input-polldev.h>
#include <linux/of_device.h>
#include <linux/mutex.h>

#define MMA8450_DRV_NAME	"mma8450"

#define MODE_CHANGE_DELAY_MS	100
#define POLL_INTERVAL		100
#define POLL_INTERVAL_MAX	500

/* register definitions */
#define MMA8450_STATUS		0x00
#define MMA8450_STATUS_ZXYDR	0x08

#define MMA8450_OUT_X8		0x01
#define MMA8450_OUT_Y8		0x02
#define MMA8450_OUT_Z8		0x03

#define MMA8450_OUT_X_LSB	0x05
#define MMA8450_OUT_X_MSB	0x06
#define MMA8450_OUT_Y_LSB	0x07
#define MMA8450_OUT_Y_MSB	0x08
#define MMA8450_OUT_Z_LSB	0x09
#define MMA8450_OUT_Z_MSB	0x0a

#define MMA8450_XYZ_DATA_CFG	0x16

#define MMA8450_CTRL_REG1	0x38
#define MMA8450_CTRL_REG2	0x39
#define MMA8450_ID		0xC6
#define MMA8450_WHO_AM_I	0x0F

enum {
	MODE_STANDBY = 0,
	MODE_2G,
	MODE_4G,
	MODE_8G,
};

/* mma8450 status */
struct mma8450 {
	struct i2c_client	*client;
	struct input_polled_dev	*idev;
	struct mutex mma8450_lock;
	u8 mode;
};

static int mma8450_read(struct mma8450 *m, unsigned off)
{
	struct i2c_client *c = m->client;
	int ret;

	ret = i2c_smbus_read_byte_data(c, off);
	if (ret < 0)
		dev_err(&c->dev,
			"failed to read register 0x%02x, error %d\n",
			off, ret);

	return ret;
}

static int mma8450_write(struct mma8450 *m, unsigned off, u8 v)
{
	struct i2c_client *c = m->client;
	int error;

	error = i2c_smbus_write_byte_data(c, off, v);
	if (error < 0) {
		dev_err(&c->dev,
			"failed to write to register 0x%02x, error %d\n",
			off, error);
		return error;
	}

	return 0;
}

static int mma8450_read_block(struct mma8450 *m, unsigned off,
			      u8 *buf, size_t size)
{
	struct i2c_client *c = m->client;
	int err;

	err = i2c_smbus_read_i2c_block_data(c, off, size, buf);
	if (err < 0) {
		dev_err(&c->dev,
			"failed to read block data at 0x%02x, error %d\n",
			MMA8450_OUT_X_LSB, err);
		return err;
	}

	return 0;
}

static void mma8450_poll(struct input_polled_dev *dev)
{
	struct mma8450 *m = dev->private;
	int x, y, z;
	int ret;
	u8 buf[6];

	mutex_lock(&m->mma8450_lock);

	ret = mma8450_read(m, MMA8450_STATUS);
	if (ret < 0 || !(ret & MMA8450_STATUS_ZXYDR)) {
		mutex_unlock(&m->mma8450_lock);
		return;
	}

	ret = mma8450_read_block(m, MMA8450_OUT_X_LSB, buf, sizeof(buf));
	if (ret < 0) {
		mutex_unlock(&m->mma8450_lock);
		return;
	}

	x = ((int)(s8)buf[1] << 4) | (buf[0] & 0xf);
	y = ((int)(s8)buf[3] << 4) | (buf[2] & 0xf);
	z = ((int)(s8)buf[5] << 4) | (buf[4] & 0xf);

	input_report_abs(dev->input, ABS_X, x);
	input_report_abs(dev->input, ABS_Y, y);
	input_report_abs(dev->input, ABS_Z, z);
	input_sync(dev->input);

	mutex_unlock(&m->mma8450_lock);
}

/* Initialize the MMA8450 chip */
static s32 mma8450_open(struct input_polled_dev *dev)
{
	struct mma8450 *m = dev->private;
	int err;

	/* enable all events from X/Y/Z, no FIFO */
	err = mma8450_write(m, MMA8450_XYZ_DATA_CFG, 0x07);
	if (err)
		return err;

	/*
	 * Sleep mode poll rate - 50Hz
	 * System output data rate - 400Hz
	 * Standby mode
	 */
	err = mma8450_write(m, MMA8450_CTRL_REG1, MODE_STANDBY);
	if (err)
		return err;
	m->mode = MODE_STANDBY;
	msleep(MODE_CHANGE_DELAY_MS);

	return 0;
}

static void mma8450_close(struct input_polled_dev *dev)
{
	struct mma8450 *m = dev->private;

	mma8450_write(m, MMA8450_CTRL_REG1, 0x00);
	mma8450_write(m, MMA8450_CTRL_REG2, 0x01);
}

static ssize_t mma8450_scalemode_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	int mode = 0;
	struct mma8450 *m;
	struct i2c_client *client = to_i2c_client(dev);

	m = i2c_get_clientdata(client);

	mutex_lock(&m->mma8450_lock);
	mode = (int)m->mode;
	mutex_unlock(&m->mma8450_lock);

	return sprintf(buf, "%d\n", mode);
}

static ssize_t mma8450_scalemode_store(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t count)
{
	unsigned long  mode;
	int ret;
	struct mma8450 *m = NULL;
	struct i2c_client *client = to_i2c_client(dev);

	ret = strict_strtoul(buf, 10, &mode);
	if (ret) {
		dev_err(dev, "string transform error\n");
		return ret;
	}

	if (mode > MODE_8G) {
		dev_warn(dev, "not supported mode %d\n", (int)mode);
		return count;
	}

	m = i2c_get_clientdata(client);

	mutex_lock(&m->mma8450_lock);
	if (mode == m->mode) {
		mutex_unlock(&m->mma8450_lock);
		return count;
	}

	ret = mma8450_write(m, MMA8450_CTRL_REG1, mode);
	if (ret < 0) {
		mutex_unlock(&m->mma8450_lock);
		return ret;
	}

	msleep(MODE_CHANGE_DELAY_MS);
	m->mode = (u8)mode;
	mutex_unlock(&m->mma8450_lock);

	return count;
}

static DEVICE_ATTR(scalemode, S_IWUSR | S_IRUGO,
			mma8450_scalemode_show, mma8450_scalemode_store);

static struct attribute *mma8450_attributes[] = {
	&dev_attr_scalemode.attr,
	NULL
};

static const struct attribute_group mma8450_attr_group = {
	.attrs = mma8450_attributes,
};

/*
 * I2C init/probing/exit functions
 */
static int mma8450_probe(struct i2c_client *c,
			 const struct i2c_device_id *id)
{
	struct input_polled_dev *idev;
	struct mma8450 *m;
	int err, client_id;
	struct i2c_adapter *adapter = NULL;

	adapter = to_i2c_adapter(c->dev.parent);
	err = i2c_check_functionality(adapter,
					 I2C_FUNC_SMBUS_BYTE |
					 I2C_FUNC_SMBUS_BYTE_DATA);
	if (!err)
		goto err_out;

	client_id = i2c_smbus_read_byte_data(c, MMA8450_WHO_AM_I);

	if (MMA8450_ID != client_id) {
		dev_err(&c->dev,
			"read chip ID 0x%x is not equal to 0x%x!\n", client_id,
			MMA8450_ID);
		err = -EINVAL;
		goto err_out;
	}

	m = kzalloc(sizeof(struct mma8450), GFP_KERNEL);
	idev = input_allocate_polled_device();
	if (!m || !idev) {
		err = -ENOMEM;
		goto err_free_mem;
	}

	m->client = c;
	m->idev = idev;
	i2c_set_clientdata(c, m);

	idev->private		= m;
	idev->input->name	= MMA8450_DRV_NAME;
	idev->input->id.bustype	= BUS_I2C;
	idev->poll		= mma8450_poll;
	idev->poll_interval	= POLL_INTERVAL;
	idev->poll_interval_max	= POLL_INTERVAL_MAX;

	__set_bit(EV_ABS, idev->input->evbit);
	input_set_abs_params(idev->input, ABS_X, -2048, 2047, 32, 32);
	input_set_abs_params(idev->input, ABS_Y, -2048, 2047, 32, 32);
	input_set_abs_params(idev->input, ABS_Z, -2048, 2047, 32, 32);

	err = input_register_polled_device(idev);
	if (err) {
		dev_err(&c->dev, "failed to register polled input device\n");
		goto err_free_mem;
	}

	mutex_init(&m->mma8450_lock);

	err = mma8450_open(idev);
	if (err) {
		dev_err(&c->dev, "failed to initialize mma8450\n");
		goto err_unreg_dev;
	}

	err = sysfs_create_group(&c->dev.kobj, &mma8450_attr_group);
	if (err) {
		dev_err(&c->dev, "create device file failed!\n");
		err = -EINVAL;
		goto err_close;
	}

	return 0;

err_close:
	mma8450_close(idev);
err_unreg_dev:
	mutex_destroy(&m->mma8450_lock);
	input_unregister_polled_device(idev);
err_free_mem:
	input_free_polled_device(idev);
	kfree(m);
err_out:
	return err;
}

static int mma8450_remove(struct i2c_client *c)
{
	struct mma8450 *m = i2c_get_clientdata(c);
	struct input_polled_dev *idev = m->idev;

	sysfs_remove_group(&c->dev.kobj, &mma8450_attr_group);
	mma8450_close(idev);
	mutex_destroy(&m->mma8450_lock);
	input_unregister_polled_device(idev);
	input_free_polled_device(idev);
	kfree(m);

	return 0;
}

static const struct i2c_device_id mma8450_id[] = {
	{ MMA8450_DRV_NAME, 0 },
	{ },
};
MODULE_DEVICE_TABLE(i2c, mma8450_id);

static const struct of_device_id mma8450_dt_ids[] = {
	{ .compatible = "fsl,mma8450", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mma8450_dt_ids);

static struct i2c_driver mma8450_driver = {
	.driver = {
		.name	= MMA8450_DRV_NAME,
		.owner	= THIS_MODULE,
		.of_match_table = mma8450_dt_ids,
	},
	.probe		= mma8450_probe,
	.remove		= mma8450_remove,
	.id_table	= mma8450_id,
};

module_i2c_driver(mma8450_driver);

MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("MMA8450 3-Axis Accelerometer Driver");
MODULE_LICENSE("GPL");
